home *** CD-ROM | disk | FTP | other *** search
/ Dr. Windows 3 / dr win3.zip / dr win3 / WINPROGS / WINSRC20.ZIP / PARSER.C < prev    next >
C/C++ Source or Header  |  1990-10-04  |  32KB  |  1,291 lines
  1. /* Parser.c (C) 1990, Mark C. Peterson, CompuServe [70441,3353]
  2.      All rights reserved.
  3.  
  4.    Code may be used in any program provided the author is credited
  5.      either during program execution or in the documentation.  Source
  6.      code may be distributed only in combination with public domain or
  7.      shareware source code.  Source code may be modified provided the
  8.      copyright notice and this message is left unchanged and all
  9.      modifications are clearly documented.
  10.  
  11.      I would appreciate a copy of any work which incorporates this code,
  12.      however this is optional.
  13.  
  14.      Mark C. Peterson
  15.      128 Hamden Ave., F
  16.      Waterbury, CT 06704
  17.      (203) 754-1162
  18. */
  19.  
  20. #include <string.h>
  21. #include <ctype.h>
  22. #include <stdio.h>
  23. #include "mpmath.h"
  24.  
  25. void findpath(char *filename, char *fullpathname);
  26. void far *farmemalloc(long bytestoalloc);
  27. void farmemfree(void far *farptr);
  28. int  stopmsg(int,unsigned char far *);
  29.  
  30. MATH_TYPE MathType = D_MATH;
  31. /* moved struct lcomplex and union ARg to mpmath.h -6-20-90 TIW */
  32.  
  33. struct ConstArg {
  34.    char *s;
  35.    int len;
  36.    union Arg a;
  37. };
  38.  
  39. struct PEND_OP {
  40.    void (far *f)(void);
  41.    int p;
  42. };
  43. struct PEND_OP far *o;
  44.  
  45. union Arg *Arg1, *Arg2, s[20], far *a, far * far *Store, far * far *Load;
  46. int StoPtr, LodPtr, OpPtr;
  47.  
  48. void (far * far *f)(void) = (void(far * far *)(void))0;
  49.  
  50. static unsigned n, ErrPtr, posp, vsp, NextOp, LastOp, InitN;
  51. static int paren, SyntaxErr, ExpectingArg;
  52. static struct ConstArg far *v;
  53. static int InitLodPtr, InitStoPtr, InitOpPtr, LastInitOp, NumVar;
  54. static int Delta16;
  55. static double fgLimit;
  56. static double fg;
  57. static int ShiftBack;     /* TIW 06-18-90 */
  58.  
  59. extern int bitshift;
  60. extern int bitshiftless1;
  61. extern long multiply(long x, long y, int bitshift);
  62. extern long divide(long x, long y, int bitshift);
  63. extern int symmetry;          /* symmetry flag for calcmand()  */
  64. extern double param[];
  65.  
  66. extern int debugflag;         /* BDT for debugging */
  67. extern int row, col, overflow, cpu, fpu;
  68. extern struct complex old, new;
  69. extern double far *dx0, far *dy0;
  70. extern long far *lx0, far *ly0;     /* BDT moved these to FAR */
  71.  
  72. #ifndef TESTING_MATH
  73.    extern double far *dx1, far *dy1;
  74.    extern long far *lx1, far *ly1;
  75.    #define dShiftx dx1[row]
  76.    #define dShifty dy1[col]
  77.    #define lShiftx lx1[row]
  78.    #define lShifty ly1[col]
  79. #else
  80.    #define dShiftx 0.0
  81.    #define dShifty 0.0
  82.    #define lShiftx 0L
  83.    #define lShifty 0L
  84. #endif
  85.  
  86. extern struct lcomplex lold, lnew;
  87. extern char FormName[];
  88.  
  89. #define LastSqr v[4].a
  90.  
  91. static char * ErrStrings[] = {
  92.    "Should be an Argument",
  93.    "Should be an Operator",
  94.    "')' needs a matching '('",
  95.    "Need more ')'",
  96.    "Undefined Operator",
  97.    "Undefined Function",
  98.    "More than one ','",
  99. };
  100.  
  101. void dStkAbs(void) {
  102.    Arg1->d.x = fabs(Arg1->d.x);
  103.    Arg1->d.y = fabs(Arg1->d.y);
  104. }
  105.  
  106. void mStkAbs(void) {
  107.    if(Arg1->m.x.Exp < 0)
  108.       Arg1->m.x.Exp = -Arg1->m.x.Exp;
  109.    if(Arg1->m.y.Exp < 0)
  110.       Arg1->m.y.Exp = -Arg1->m.y.Exp;
  111. }
  112.  
  113. void lStkAbs(void) {
  114.    Arg1->l.x = labs(Arg1->l.x);
  115.    Arg1->l.y = labs(Arg1->l.y);
  116. }
  117.  
  118. void (*StkAbs)(void) = dStkAbs;
  119.  
  120. void dStkSqr(void) {
  121.    LastSqr.d.x = Arg1->d.x * Arg1->d.x;
  122.    LastSqr.d.y = Arg1->d.y * Arg1->d.y;
  123.    Arg1->d.y = Arg1->d.x * Arg1->d.y * 2.0;
  124.    Arg1->d.x = LastSqr.d.x - LastSqr.d.y;
  125.    LastSqr.d.x += LastSqr.d.y;
  126. }
  127.  
  128. void mStkSqr(void) {
  129.    LastSqr.m.x = MPmul(Arg1->m.x, Arg1->m.x);
  130.    LastSqr.m.y = MPmul(Arg1->m.y, Arg1->m.y);
  131.    Arg1->m.y = MPmul(Arg1->m.x, Arg1->m.y);
  132.    Arg1->m.y.Exp++;
  133.    Arg1->m.x = MPsub(LastSqr.m.x, LastSqr.m.y);
  134.    LastSqr.m.x = MPadd(LastSqr.m.x, LastSqr.m.y);
  135. }
  136.  
  137. void lStkSqr(void) {
  138.    LastSqr.l.x = multiply(Arg1->l.x, Arg1->l.x, bitshift);
  139.    LastSqr.l.y = multiply(Arg1->l.y, Arg1->l.y, bitshift);
  140.    Arg1->l.y = multiply(Arg1->l.x, Arg1->l.y, bitshift) << 1;
  141.    Arg1->l.x = LastSqr.l.x - LastSqr.l.y;
  142.    LastSqr.l.x += LastSqr.l.y;
  143. }
  144.  
  145. void (*StkSqr)(void) = dStkSqr;
  146.  
  147. void dStkAdd(void) {
  148.    Arg2->d.x += Arg1->d.x;
  149.    Arg2->d.y += Arg1->d.y;
  150.    Arg1--;
  151.    Arg2--;
  152. }
  153.  
  154. void mStkAdd(void) {
  155.    Arg2->m = MPCadd(Arg2->m, Arg1->m);
  156.    Arg1--;
  157.    Arg2--;
  158. }
  159.  
  160. void lStkAdd(void) {
  161.    Arg2->l.x += Arg1->l.x;
  162.    Arg2->l.y += Arg1->l.y;
  163.    Arg1--;
  164.    Arg2--;
  165. }
  166.  
  167. void (*StkAdd)(void) = dStkAdd;
  168.  
  169. void dStkSub(void) {
  170.    Arg2->d.x -= Arg1->d.x;
  171.    Arg2->d.y -= Arg1->d.y;
  172.    Arg1--;
  173.    Arg2--;
  174. }
  175.  
  176. void mStkSub(void) {
  177.    Arg2->m = MPCsub(Arg2->m, Arg1->m);
  178.    Arg1--;
  179.    Arg2--;
  180. }
  181.  
  182. void lStkSub(void) {
  183.    Arg2->l.x -= Arg1->l.x;
  184.    Arg2->l.y -= Arg1->l.y;
  185.    Arg1--;
  186.    Arg2--;
  187. }
  188.  
  189. void (*StkSub)(void) = dStkSub;
  190.  
  191. void dStkConj(void) {
  192.    Arg1->d.y = -Arg1->d.y;
  193. }
  194.  
  195. void mStkConj(void) {
  196.    Arg1->m.y.Exp ^= 0x8000;
  197. }
  198.  
  199. void lStkConj(void) {
  200.    Arg1->l.y = -Arg1->l.y;
  201. }
  202.  
  203. void (*StkConj)(void) = dStkConj;
  204.  
  205. void dStkReal(void) {
  206.    Arg1->d.y = 0.0;
  207. }
  208.  
  209. void mStkReal(void) {
  210.    Arg1->m.y.Mant = (long)(Arg1->m.y.Exp = 0);
  211. }
  212.  
  213. void lStkReal(void) {
  214.    Arg1->l.y = 0l;
  215. }
  216.  
  217. void (*StkReal)(void) = dStkReal;
  218.  
  219. void dStkImag(void) {
  220.    Arg1->d.x = 0.0;
  221. }
  222.  
  223. void mStkImag(void) {
  224.    Arg1->m.x.Mant = (long)(Arg1->m.x.Exp = 0);
  225. }
  226.  
  227. void lStkImag(void) {
  228.    Arg1->l.x = 0l;
  229. }
  230.  
  231. void (*StkImag)(void) = dStkImag;
  232.  
  233. void dStkNeg(void) {
  234.    Arg1->d.x = -Arg1->d.x;
  235.    Arg1->d.y = -Arg1->d.y;
  236. }
  237.  
  238. void mStkNeg(void) {
  239.    Arg1->m.x.Exp ^= 0x8000;
  240.    Arg1->m.y.Exp ^= 0x8000;
  241. }
  242.  
  243. void lStkNeg(void) {
  244.    Arg1->l.x = -Arg1->l.x;
  245.    Arg1->l.y = -Arg1->l.y;
  246. }
  247.  
  248. void (*StkNeg)(void) = dStkNeg;
  249.  
  250. void dStkMul(void) {
  251.    FPUcplxmul(&Arg2->d, &Arg1->d, &Arg2->d);
  252.    Arg1--;
  253.    Arg2--;
  254. }
  255.  
  256. void mStkMul(void) {
  257.    Arg2->m = MPCmul(Arg2->m, Arg1->m);
  258.    Arg1--;
  259.    Arg2--;
  260. }
  261.  
  262. void lStkMul(void) {
  263.    long x, y;
  264.  
  265.    x = multiply(Arg2->l.x, Arg1->l.x, bitshift) -
  266.        multiply(Arg2->l.y, Arg1->l.y, bitshift);
  267.    y = multiply(Arg2->l.y, Arg1->l.x, bitshift) +
  268.        multiply(Arg2->l.x, Arg1->l.y, bitshift);
  269.    Arg2->l.x = x;
  270.    Arg2->l.y = y;
  271.    Arg1--;
  272.    Arg2--;
  273. }
  274.  
  275. void (*StkMul)(void) = dStkMul;
  276.  
  277. void dStkDiv(void) {
  278.    FPUcplxdiv(&Arg2->d, &Arg1->d, &Arg2->d);
  279.    Arg1--;
  280.    Arg2--;
  281. }
  282.  
  283. void mStkDiv(void) {
  284.    Arg2->m = MPCdiv(Arg2->m, Arg1->m);
  285.    Arg1--;
  286.    Arg2--;
  287. }
  288.  
  289. void lStkDiv(void) {
  290.    long x, y, mod, x2, y2;
  291.  
  292.    mod = multiply(Arg1->l.x, Arg1->l.x, bitshift) +
  293.          multiply(Arg1->l.y, Arg1->l.y, bitshift);
  294.    x = divide(Arg1->l.x, mod, bitshift);
  295.    y = -divide(Arg1->l.y, mod, bitshift);
  296.    /* pb 900617 changed next 4 lines to use x2,y2 instead of x,y */
  297.    x2 = multiply(Arg2->l.x, x, bitshift) - multiply(Arg2->l.y, y, bitshift);
  298.    y2 = multiply(Arg2->l.y, x, bitshift) + multiply(Arg2->l.x, y, bitshift);
  299.    Arg2->l.x = x2;
  300.    Arg2->l.y = y2;
  301.    Arg1--;
  302.    Arg2--;
  303. }
  304.  
  305. void (*StkDiv)(void) = dStkDiv;
  306.  
  307. void StkSto(void) {
  308.    *Store[StoPtr++] = *Arg1;
  309. }
  310.  
  311. void StkLod(void) {
  312.    Arg1++;
  313.    Arg2++;
  314.    *Arg1 = *Load[LodPtr++];
  315. }
  316.  
  317. void dStkMod(void) {
  318.    Arg1->d.x = (Arg1->d.x * Arg1->d.x) + (Arg1->d.y * Arg1->d.y);
  319.    Arg1->d.y = 0.0;
  320. }
  321.  
  322. void mStkMod(void) {
  323.    Arg1->m.x = MPCmod(Arg1->m);
  324.    Arg1->m.y.Mant = (long)(Arg1->m.y.Exp = 0);
  325. }
  326.  
  327. void lStkMod(void) {
  328.    Arg1->l.x = multiply(Arg2->l.x, Arg1->l.x, bitshift) +
  329.                  multiply(Arg2->l.y, Arg1->l.y, bitshift);
  330.    if(Arg1->l.x < 0)
  331.       overflow = 1;
  332.    Arg1->l.y = 0L;
  333. }
  334.  
  335. void (*StkMod)(void) = dStkMod;
  336.  
  337. void StkClr(void) {
  338.    s[0] = *Arg1;
  339.    Arg1 = &s[0];
  340.    Arg2 = Arg1;
  341.    Arg2--;
  342. }
  343.  
  344. void dStkSin(void) {
  345.    double sinx, cosx, sinhy, coshy;
  346.  
  347.    FPUsincos(&Arg1->d.x, &sinx, &cosx);
  348.    FPUsinhcosh(&Arg1->d.y, &sinhy, &coshy);
  349.    Arg1->d.x = sinx*coshy;
  350.    Arg1->d.y = cosx*sinhy;
  351. }
  352.  
  353. void mStkSin(void) {
  354.    Arg1->d = MPC2cmplx(Arg1->m);
  355.    dStkSin();
  356.    Arg1->m = cmplx2MPC(Arg1->d);
  357. }
  358.  
  359. void lStkSin(void) {
  360.    int f;
  361.    long x, y, sinx, cosx, sinhy, coshy;
  362.  
  363.    x = Arg1->l.x >> Delta16;
  364.    y = Arg1->l.y >> Delta16;
  365.    SinCos086(x, &sinx, &cosx);
  366.    SinhCosh086(y, &sinhy, &coshy);
  367.    Arg1->l.x = multiply(sinx, coshy, ShiftBack); /* TIW 06-18-90 */
  368.    Arg1-